package sucre 
import ve.org.src.sesiones.CacheSeguridad
import ve.org.src.constantes.LoginConstantes

import ve.org.src.util.DateUtils
import java.sql.SQLException
import ve.org.src.utils.encryption.CryptoUtils
import ve.org.src.sesiones.ManejadorSesiones
import ve.org.src.util.DirectivasUtils

class LoginController {

    def loginService

    def index = { }

    def auth = {
        

        String msg=''
        int recargarPagina = 0
        String style='errors'
        boolean iniciarSesion=true
        try{
            //1. se verifica si se esta denegando el acceso
            if(params.acceso!=null && params.acceso=='false'){
                session.invalidate()
                msg='''Acceso denegado a funciones del sistema/Contacte
                    con Soporte Tecnico'''
                recargarPagina=1
                iniciarSesion=false     
                redirect(action:"cerrarSesionInactiva")
            }
            //2. se verifica si la sesion esta iniciada y el usuario esta activo
            if(iniciarSesion)
            if(session.seguridad_usuario!=null
                && !ManejadorSesiones.verificarInactividad(
                    session.seguridad_usuario,false)){
                
                msg='La sesion esta iniciada'
                iniciarSesion=false
                redirect(controller:"principal",action:"index")                
            }
            //3. se verifica si la sesion esta iniciada y el usuario esta inactivo
            if(iniciarSesion)
            if(session.seguridad_usuario!=null
                && ManejadorSesiones.verificarInactividad(
                    session.seguridad_usuario,false)){
                
                session.invalidate()
                iniciarSesion=false
                redirect(action:"cerrarSesionInactiva")                
            }
            //4. se verifica si se esta actualizando
            if(iniciarSesion)
            if(params.flag==null || params.flag != "1"){
                iniciarSesion=false
            }
            //5. se verifica si llegaron los parametros
            if(iniciarSesion)
            if(!params.usuario || !params.password){
                msg='El usuario y/o clave es requerido'
                iniciarSesion=false
            }
            //6. se verifica si los parametros tienen el largo minimo y maximo permitido
            if(iniciarSesion)
            if(params.usuario.length()<LoginConstantes.USUARIO_MIN_LENGTH
                || params.usuario.length()>LoginConstantes.USUARIO_MAX_LENGTH){
                msg='Parametros incorrectos'
                iniciarSesion=false
            }
            //estando los pasos del 1 al 6 correctos se procede a iniciar la sesion
            if(iniciarSesion){
                //1. se busca el usuario
                println " request.getRemoteAddr()" + request.getRemoteAddr()
                
                def login = loginService.validarUsuario(
                    params.usuario,params.password,request.getRemoteAddr())
                if(login!=null){

                    if(login.Resultado==LoginConstantes.PASSWORD_VALIDO){
                        if(login.Usuario.estado==LoginConstantes.ESTADO_USUARIO_ACTIVO){                            
                                if(ManejadorSesiones.verificarSesion(
                                        login.Usuario.login,request.
                                            getRemoteAddr())){

                                    def user=login.Usuario
                                    
                                        println '\tIniciando Sesion:'
                                        //se crean las variables de sesion
                                        // para el usuario
                                        session[user.login] = 0
                                        session.seguridad_usuario = user.login
                                        session.seguridad_perfil = user.perfil.nombre
                                        session.seguridad_actionMenu = loginService.cargarAccionesMenu(user)
                                        session.seguridad_funcionesHabilitadas = loginService.cargarFuncionesHabilitadas(session.seguridad_actionMenu)
                                        print '...'
                                        //loginService.registraAuditoria(session["seguridad_usuario"],'auth','login',request.getRemoteAddr().toString())
                                        if(DateUtils.isBeforeToday(user.fechaCaducidad)){
                                            session.seguridad_actualizar_password='actualizando'
                                            redirect(action:"actualizarPassword")
                                        }else{
                                            redirect(controller:"principal",action:"index")
                                        }                                   
                                    
                                    
                                }else{
                                    msg='El usuario ha iniciado sesion'
                                }                    
                        }else{
                            msg=message(code:'def.usuario.estado.'+login.Usuario.estado)
                        }
                    }else{
                        msg='El nombre de usuario o la clave introducidos no son correctos'
                        def intentos = session[login.get('Usuario').login];
                        session[login.get('Usuario').login] = ((intentos>=0)?intentos:0) + 1
                        if(session[login.get('Usuario').login] == LoginConstantes.CANTIDAD_REINTENTOS){
                            loginService.bloquearUsuario(login.get('Usuario'),LoginConstantes.ESTADO_USUARIO_BLOQUEADO_REINTENTOS)
                            session[login.get('Usuario').login] = 0
                            msg = message(code:'login.auth.usuario.inactivo')
                            session.invalidate()
                        }
                    }
                }else{
                    msg='Usuario no encontrado'
                }
            }
        }catch(SocketException e){
            msg = message(code:'login.auth.conexion.error')
        }
        catch(SQLException e2){
            msg = message(code:'login.auth.conexion.error')
        }catch(Exception e3){
            msg = message(code:'login.auth.default.error')
            println 'error general: '+e3
        }
        return[respuesta:msg,estilo:style,recargarPagina:recargarPagina]
    }
    def actualizarPassword = {
        println params
        if(!session["seguridad_usuario"])
        {
            redirect(action:"auth")
            return
        }

        if(!params.flag || params.flag != "1")
        return;
        
        def estatus = 0;

        if(!params.new_password || !params.new_password_b)
        {
            flash.message = message(code:'login.faltan.campos')
            estatus = 0
        }
        else if(!(params.new_password.equals(params.new_password_b)))
        {
            flash.message = message(
                code:'login.actualizarPassword.password.diferente')
            estatus = 0
        }
        else
        {
            flash.message = ""
            def response=validarDirectivasSeguridad(params.new_password)
            
            if(response.size()>0){
                def msg=''
                each{dir->
                    msg=msg+response.msg+"\n"
                    
                }
                flash.message = '''Estimado Usuario, la clave debe
                                 cumplir con las siguientes directivas:'''
                
                estatus = 0
                return [estilo:'errors', estatus:estatus,directivas:response]
            }
            else {
                if(loginService.actualizarPassword(session["seguridad_usuario"],
                        params.new_password,request.getRemoteAddr())) {
                    flash.message = message(
                        code:'login.actualizarPassword.password.modificado')
                    estatus = 1
                }
                else {
                    flash.message = message(
                                    'login.actualizarPassword.password.error')
                    estatus = 0
                }
            }
        }
        return [estilo:'message', estatus:estatus]
    }

    def cerrarSesion = {

        if(loginService.cerrarSesion(session["seguridad_usuario"],
                request.getRemoteAddr())) {
            ManejadorSesiones.caducarSesion(session["seguridad_usuario"])
            session.invalidate()
            /*session.removeAttribute("seguridad_usuario")
            session.removeAttribute("seguridad_actionMenu")*/
            
        }
        
        //redirect(action:"auth")
    }   
    def validarDirectivasSeguridad(String clave){
        
        def response=[:]
        def msgDirectivas=[]
        Boolean existePassword=false
        def usuario = Password.findAllByUsuario(CacheSeguridad.getUsuario(
                session["seguridad_usuario"]))
        if(usuario != null)
        {
            usuario.each{
                dir->
                //println "result passwords"+dir.clave
                if(dir.clave.equals(CryptoUtils.codificarContrasenna(clave)))
                {
                    existePassword=true
                    msgDirectivas.add([code:'pass_rep',valor:'',
                            msg:'Password ya Existe'])
                }

            }
        }
        if(!existePassword){
            msgDirectivas = validarDirectivas(clave)
        }
        return msgDirectivas

    }
    def validarDirectivas(String clave){
        def response=[:]
        def directivas=[]
        def directiva2=[]
        def directivaRespuesta=[]

        try{
            directivas=DirectivaPassword.createCriteria().list{
                eq('activa',true)
            }

            directiva2=DirectivasUtils.validarDirectivas(directivas,clave)
            directiva2.each{dir->

                if(!dir.sts && dir.code!=LoginConstantes.directiva_num_pass){
                    directivaRespuesta.add(
                        [code:dir.code,valor:dir.value,msg:dir.des])
                }
            }
            return directivaRespuesta

        }catch(Exception e){
            response.put('respuesta',
                CodigoDevolucionConstantes.ERROR_COMUNICACION_BASE_DATOS)
            return response
        }
    }
    def cerrarSesionInactiva = {
        String msg=''
        String style='errors'
        int recargarPagina = 1
        msg='''Acceso denegado a funciones del
               sistema/contacte con Soporte Tecnico'''
        redirect(controller: "login", action: "cerrarSesion")
    }
    

}
